home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / info.lzh / INFO / GCC_INFO.15 < prev    next >
Encoding:
GNU Info File  |  1993-10-21  |  48.6 KB  |  1,175 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.  
  4.    This file documents the use and the internals of the GNU compiler.
  5.  
  6.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the sections entitled "GNU General Public License" and "Protect
  15. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  16. original, and provided that the entire resulting derived work is
  17. distributed under the terms of a permission notice identical to this
  18. one.
  19.  
  20.    Permission is granted to copy and distribute translations of this
  21. manual into another language, under the above conditions for modified
  22. versions, except that the sections entitled "GNU General Public
  23. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  24. permission notice, may be included in translations approved by the Free
  25. Software Foundation instead of in the original English.
  26.  
  28. File: gcc.info,  Node: Driver,  Next: Run-time Target,  Up: Target Macros
  29.  
  30. Controlling the Compilation Driver, `gcc'
  31. =========================================
  32.  
  33. `SWITCH_TAKES_ARG (CHAR)'
  34.      A C expression which determines whether the option `-CHAR' takes
  35.      arguments.  The value should be the number of arguments that
  36.      option takes-zero, for many options.
  37.  
  38.      By default, this macro is defined to handle the standard options
  39.      properly.  You need not define it unless you wish to add additional
  40.      options which take arguments.
  41.  
  42. `WORD_SWITCH_TAKES_ARG (NAME)'
  43.      A C expression which determines whether the option `-NAME' takes
  44.      arguments.  The value should be the number of arguments that
  45.      option takes-zero, for many options.  This macro rather than
  46.      `SWITCH_TAKES_ARG' is used for multi-character option names.
  47.  
  48.      By default, this macro is defined as
  49.      `DEFAULT_WORD_SWITCH_TAKES_ARG', which handles the standard options
  50.      properly.  You need not define `WORD_SWITCH_TAKES_ARG' unless you
  51.      wish to add additional options which take arguments.  Any
  52.      redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and then
  53.      check for additional options.
  54.  
  55. `SWITCHES_NEED_SPACES'
  56.      A string-valued C expression which is nonempty if the linker needs
  57.      a space between the `-L' or `-o' option and its argument.
  58.  
  59.      If this macro is not defined, the default value is 0.
  60.  
  61. `CPP_SPEC'
  62.      A C string constant that tells the GNU CC driver program options to
  63.      pass to CPP.  It can also specify how to translate options you
  64.      give to GNU CC into options for GNU CC to pass to the CPP.
  65.  
  66.      Do not define this macro if it does not need to do anything.
  67.  
  68. `NO_BUILTIN_SIZE_TYPE'
  69.      If this macro is defined, the preprocessor will not define the
  70.      builtin macro `__SIZE_TYPE__'.  The macro `__SIZE_TYPE__' must
  71.      then be defined by `CPP_SPEC' instead.
  72.  
  73.      This should be defined if `SIZE_TYPE' depends on target dependent
  74.      flags which are not accessible to the preprocessor.  Otherwise, it
  75.      should not be defined.
  76.  
  77. `NO_BUILTIN_PTRDIFF_TYPE'
  78.      If this macro is defined, the preprocessor will not define the
  79.      builtin macro `__PTRDIFF_TYPE__'.  The macro `__PTRDIFF_TYPE__'
  80.      must then be defined by `CPP_SPEC' instead.
  81.  
  82.      This should be defined if `PTRDIFF_TYPE' depends on target
  83.      dependent flags which are not accessible to the preprocessor.
  84.      Otherwise, it should not be defined.
  85.  
  86. `SIGNED_CHAR_SPEC'
  87.      A C string constant that tells the GNU CC driver program options to
  88.      pass to CPP.  By default, this macro is defined to pass the option
  89.      `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as
  90.      `unsigned char' by `cc1'.
  91.  
  92.      Do not define this macro unless you need to override the default
  93.      definition.
  94.  
  95. `CC1_SPEC'
  96.      A C string constant that tells the GNU CC driver program options to
  97.      pass to `cc1'.  It can also specify how to translate options you
  98.      give to GNU CC into options for GNU CC to pass to the `cc1'.
  99.  
  100.      Do not define this macro if it does not need to do anything.
  101.  
  102. `CC1PLUS_SPEC'
  103.      A C string constant that tells the GNU CC driver program options to
  104.      pass to `cc1plus'.  It can also specify how to translate options
  105.      you give to GNU CC into options for GNU CC to pass to the
  106.      `cc1plus'.
  107.  
  108.      Do not define this macro if it does not need to do anything.
  109.  
  110. `ASM_SPEC'
  111.      A C string constant that tells the GNU CC driver program options to
  112.      pass to the assembler.  It can also specify how to translate
  113.      options you give to GNU CC into options for GNU CC to pass to the
  114.      assembler.  See the file `sun3.h' for an example of this.
  115.  
  116.      Do not define this macro if it does not need to do anything.
  117.  
  118. `ASM_FINAL_SPEC'
  119.      A C string constant that tells the GNU CC driver program how to
  120.      run any programs which cleanup after the normal assembler.
  121.      Normally, this is not needed.  See the file `mips.h' for an
  122.      example of this.
  123.  
  124.      Do not define this macro if it does not need to do anything.
  125.  
  126. `LINK_SPEC'
  127.      A C string constant that tells the GNU CC driver program options to
  128.      pass to the linker.  It can also specify how to translate options
  129.      you give to GNU CC into options for GNU CC to pass to the linker.
  130.  
  131.      Do not define this macro if it does not need to do anything.
  132.  
  133. `LIB_SPEC'
  134.      Another C string constant used much like `LINK_SPEC'.  The
  135.      difference between the two is that `LIB_SPEC' is used at the end
  136.      of the command given to the linker.
  137.  
  138.      If this macro is not defined, a default is provided that loads the
  139.      standard C library from the usual place.  See `gcc.c'.
  140.  
  141. `STARTFILE_SPEC'
  142.      Another C string constant used much like `LINK_SPEC'.  The
  143.      difference between the two is that `STARTFILE_SPEC' is used at the
  144.      very beginning of the command given to the linker.
  145.  
  146.      If this macro is not defined, a default is provided that loads the
  147.      standard C startup file from the usual place.  See `gcc.c'.
  148.  
  149. `ENDFILE_SPEC'
  150.      Another C string constant used much like `LINK_SPEC'.  The
  151.      difference between the two is that `ENDFILE_SPEC' is used at the
  152.      very end of the command given to the linker.
  153.  
  154.      Do not define this macro if it does not need to do anything.
  155.  
  156. `LINK_LIBGCC_SPECIAL'
  157.      Define this macro meaning that `gcc' should find the library
  158.      `libgcc.a' by hand, rather than passing the argument `-lgcc' to
  159.      tell the linker to do the search; also, `gcc' should not generate
  160.      `-L' options to pass to the linker (as it normally does).
  161.  
  162. `LINK_LIBGCC_SPECIAL_1'
  163.      Define this macro meaning that `gcc' should find the library
  164.      `libgcc.a' by hand, rather than passing the argument `-lgcc' to
  165.      tell the linker to do the search.
  166.  
  167. `RELATIVE_PREFIX_NOT_LINKDIR'
  168.      Define this macro to tell `gcc' that it should only translate a
  169.      `-B' prefix into a `-L' linker option if the prefix indicates an
  170.      absolute file name.
  171.  
  172. `STANDARD_EXEC_PREFIX'
  173.      Define this macro as a C string constant if you wish to override
  174.      the standard choice of `/usr/local/lib/gcc-lib/' as the default
  175.      prefix to try when searching for the executable files of the
  176.      compiler.
  177.  
  178. `MD_EXEC_PREFIX'
  179.      If defined, this macro is an additional prefix to try after
  180.      `STANDARD_EXEC_PREFIX'.  `MD_EXEC_PREFIX' is not searched when the
  181.      `-b' option is used, or the compiler is built as a cross compiler.
  182.  
  183. `STANDARD_STARTFILE_PREFIX'
  184.      Define this macro as a C string constant if you wish to override
  185.      the standard choice of `/usr/local/lib/' as the default prefix to
  186.      try when searching for startup files such as `crt0.o'.
  187.  
  188. `MD_STARTFILE_PREFIX'
  189.      If defined, this macro supplies an additional prefix to try after
  190.      the standard prefixes.  `MD_EXEC_PREFIX' is not searched when the
  191.      `-b' option is used, or when the compiler is built as a cross
  192.      compiler.
  193.  
  194. `MD_STARTFILE_PREFIX_1'
  195.      If defined, this macro supplies yet another prefix to try after the
  196.      standard prefixes.  It is not searched when the `-b' option is
  197.      used, or when the compiler is built as a cross compiler.
  198.  
  199. `LOCAL_INCLUDE_DIR'
  200.      Define this macro as a C string constant if you wish to override
  201.      the standard choice of `/usr/local/include' as the default prefix
  202.      to try when searching for local header files.  `LOCAL_INCLUDE_DIR'
  203.      comes before `SYSTEM_INCLUDE_DIR' in the search order.
  204.  
  205.      Cross compilers do not use this macro and do not search either
  206.      `/usr/local/include' or its replacement.
  207.  
  208. `SYSTEM_INCLUDE_DIR'
  209.      Define this macro as a C string constant if you wish to specify a
  210.      system-specific directory to search for header files before the
  211.      standard directory.  `SYSTEM_INCLUDE_DIR' comes before
  212.      `STANDARD_INCLUDE_DIR' in the search order.
  213.  
  214.      Cross compilers do not use this macro and do not search the
  215.      directory specified.
  216.  
  217. `STANDARD_INCLUDE_DIR'
  218.      Define this macro as a C string constant if you wish to override
  219.      the standard choice of `/usr/include' as the default prefix to try
  220.      when searching for header files.
  221.  
  222.      Cross compilers do not use this macro and do not search either
  223.      `/usr/include' or its replacement.
  224.  
  225. `INCLUDE_DEFAULTS'
  226.      Define this macro if you wish to override the entire default
  227.      search path for include files.  The default search path includes
  228.      `GCC_INCLUDE_DIR', `LOCAL_INCLUDE_DIR', `SYSTEM_INCLUDE_DIR',
  229.      `GPLUSPLUS_INCLUDE_DIR', and `STANDARD_INCLUDE_DIR'.  In addition,
  230.      `GPLUSPLUS_INCLUDE_DIR' and `GCC_INCLUDE_DIR' are defined
  231.      automatically by `Makefile', and specify private search areas for
  232.      GCC.  The directory `GPLUSPLUS_INCLUDE_DIR' is used only for C++
  233.      programs.
  234.  
  235.      The definition should be an initializer for an array of structures.
  236.      Each array element should have two elements: the directory name (a
  237.      string constant) and a flag for C++-only directories.  Mark the
  238.      end of the array with a null element.  For example, here is the
  239.      definition used for VMS:
  240.  
  241.           #define INCLUDE_DEFAULTS \
  242.           {                                       \
  243.             { "GNU_GXX_INCLUDE:", 1},             \
  244.             { "GNU_CC_INCLUDE:", 0},              \
  245.             { "SYS$SYSROOT:[SYSLIB.]", 0},        \
  246.             { ".", 0},                            \
  247.             { 0, 0}                               \
  248.           }
  249.  
  250.    Here is the order of prefixes tried for exec files:
  251.  
  252.   1. Any prefixes specified by the user with `-B'.
  253.  
  254.   2. The environment variable `GCC_EXEC_PREFIX', if any.
  255.  
  256.   3. The directories specified by the environment variable
  257.      `COMPILER_PATH'.
  258.  
  259.   4. The macro `STANDARD_EXEC_PREFIX'.
  260.  
  261.   5. `/usr/lib/gcc/'.
  262.  
  263.   6. The macro `MD_EXEC_PREFIX', if any.
  264.  
  265.    Here is the order of prefixes tried for startfiles:
  266.  
  267.   1. Any prefixes specified by the user with `-B'.
  268.  
  269.   2. The environment variable `GCC_EXEC_PREFIX', if any.
  270.  
  271.   3. The directories specified by the environment variable
  272.      `LIBRARY_PATH'.
  273.  
  274.   4. The macro `STANDARD_EXEC_PREFIX'.
  275.  
  276.   5. `/usr/lib/gcc/'.
  277.  
  278.   6. The macro `MD_EXEC_PREFIX', if any.
  279.  
  280.   7. The macro `MD_STARTFILE_PREFIX', if any.
  281.  
  282.   8. The macro `STANDARD_STARTFILE_PREFIX'.
  283.  
  284.   9. `/lib/'.
  285.  
  286.  10. `/usr/lib/'.
  287.  
  289. File: gcc.info,  Node: Run-time Target,  Next: Storage Layout,  Prev: Driver,  Up: Target Macros
  290.  
  291. Run-time Target Specification
  292. =============================
  293.  
  294. `CPP_PREDEFINES'
  295.      Define this to be a string constant containing `-D' options to
  296.      define the predefined macros that identify this machine and system.
  297.      These macros will be predefined unless the `-ansi' option is
  298.      specified.
  299.  
  300.      In addition, a parallel set of macros are predefined, whose names
  301.      are made by appending `__' at the beginning and at the end.  These
  302.      `__' macros are permitted by the ANSI standard, so they are
  303.      predefined regardless of whether `-ansi' is specified.
  304.  
  305.      For example, on the Sun, one can use the following value:
  306.  
  307.           "-Dmc68000 -Dsun -Dunix"
  308.  
  309.      The result is to define the macros `__mc68000__', `__sun__' and
  310.      `__unix__' unconditionally, and the macros `mc68000', `sun' and
  311.      `unix' provided `-ansi' is not specified.
  312.  
  313. `STDC_VALUE'
  314.      Define the value to be assigned to the built-in macro `__STDC__'.
  315.      The default is the value `1'.
  316.  
  317. `extern int target_flags;'
  318.      This declaration should be present.
  319.  
  320. `TARGET_...'
  321.      This series of macros is to allow compiler command arguments to
  322.      enable or disable the use of optional features of the target
  323.      machine.  For example, one machine description serves both the
  324.      68000 and the 68020; a command argument tells the compiler whether
  325.      it should use 68020-only instructions or not.  This command
  326.      argument works by means of a macro `TARGET_68020' that tests a bit
  327.      in `target_flags'.
  328.  
  329.      Define a macro `TARGET_FEATURENAME' for each such option.  Its
  330.      definition should test a bit in `target_flags'; for example:
  331.  
  332.           #define TARGET_68020 (target_flags & 1)
  333.  
  334.      One place where these macros are used is in the
  335.      condition-expressions of instruction patterns.  Note how
  336.      `TARGET_68020' appears frequently in the 68000 machine description
  337.      file, `m68k.md'.  Another place they are used is in the
  338.      definitions of the other macros in the `MACHINE.h' file.
  339.  
  340. `TARGET_SWITCHES'
  341.      This macro defines names of command options to set and clear bits
  342.      in `target_flags'.  Its definition is an initializer with a
  343.      subgrouping for each command option.
  344.  
  345.      Each subgrouping contains a string constant, that defines the
  346.      option name, and a number, which contains the bits to set in
  347.      `target_flags'.  A negative number says to clear bits instead; the
  348.      negative of the number is which bits to clear.  The actual option
  349.      name is made by appending `-m' to the specified name.
  350.  
  351.      One of the subgroupings should have a null string.  The number in
  352.      this grouping is the default value for `target_flags'.  Any target
  353.      options act starting with that value.
  354.  
  355.      Here is an example which defines `-m68000' and `-m68020' with
  356.      opposite meanings, and picks the latter as the default:
  357.  
  358.           #define TARGET_SWITCHES \
  359.             { { "68020", 1},      \
  360.               { "68000", -1},     \
  361.               { "", 1}}
  362.  
  363. `TARGET_OPTIONS'
  364.      This macro is similar to `TARGET_SWITCHES' but defines names of
  365.      command options that have values.  Its definition is an
  366.      initializer with a subgrouping for each command option.
  367.  
  368.      Each subgrouping contains a string constant, that defines the
  369.      fixed part of the option name, and the address of a variable.  The
  370.      variable, type `char *', is set to the variable part of the given
  371.      option if the fixed part matches.  The actual option name is made
  372.      by appending `-m' to the specified name.
  373.  
  374.      Here is an example which defines `-mshort-data-NUMBER'.  If the
  375.      given option is `-mshort-data-512', the variable `m88k_short_data'
  376.      will be set to the string `"512"'.
  377.  
  378.           extern char *m88k_short_data;
  379.           #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }
  380.  
  381. `TARGET_VERSION'
  382.      This macro is a C statement to print on `stderr' a string
  383.      describing the particular machine description choice.  Every
  384.      machine description should define `TARGET_VERSION'.  For example:
  385.  
  386.           #ifdef MOTOROLA
  387.           #define TARGET_VERSION \
  388.             fprintf (stderr, " (68k, Motorola syntax)");
  389.           #else
  390.           #define TARGET_VERSION \
  391.             fprintf (stderr, " (68k, MIT syntax)");
  392.           #endif
  393.  
  394. `OVERRIDE_OPTIONS'
  395.      Sometimes certain combinations of command options do not make
  396.      sense on a particular target machine.  You can define a macro
  397.      `OVERRIDE_OPTIONS' to take account of this.  This macro, if
  398.      defined, is executed once just after all the command options have
  399.      been parsed.
  400.  
  401.      Don't use this macro to turn on various extra optimizations for
  402.      `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.
  403.  
  404. `OPTIMIZATION_OPTIONS (LEVEL)'
  405.      Some machines may desire to change what optimizations are
  406.      performed for various optimization levels.   This macro, if
  407.      defined, is executed once just after the optimization level is
  408.      determined and before the remainder of the command options have
  409.      been parsed.  Values set in this macro are used as the default
  410.      values for the other command line options.
  411.  
  412.      LEVEL is the optimization level specified; 2 if -O2 is specified,
  413.      1 if -O is specified, and 0 if neither is specified.
  414.  
  415.      *Do not examine `write_symbols' in this macro!* The debugging
  416.      options are not supposed to alter the generated code.
  417.  
  419. File: gcc.info,  Node: Storage Layout,  Next: Type Layout,  Prev: Run-time Target,  Up: Target Macros
  420.  
  421. Storage Layout
  422. ==============
  423.  
  424.    Note that the definitions of the macros in this table which are
  425. sizes or alignments measured in bits do not need to be constant.  They
  426. can be C expressions that refer to static variables, such as the
  427. `target_flags'.  *Note Run-time Target::.
  428.  
  429. `BITS_BIG_ENDIAN'
  430.      Define this macro to be the value 1 if the most significant bit in
  431.      a byte has the lowest number; otherwise define it to be the value
  432.      zero.  This means that bit-field instructions count from the most
  433.      significant bit.  If the machine has no bit-field instructions,
  434.      then this must still be defined, but it doesn't matter which value
  435.      it is defined to.
  436.  
  437.      This macro does not affect the way structure fields are packed into
  438.      bytes or words; that is controlled by `BYTES_BIG_ENDIAN'.
  439.  
  440. `BYTES_BIG_ENDIAN'
  441.      Define this macro to be 1 if the most significant byte in a word
  442.      has the lowest number.
  443.  
  444. `WORDS_BIG_ENDIAN'
  445.      Define this macro to be 1 if, in a multiword object, the most
  446.      significant word has the lowest number.  This applies to both
  447.      memory locations and registers; GNU CC fundamentally assumes that
  448.      the order of words in memory is the same as the order in registers.
  449.  
  450. `BITS_PER_UNIT'
  451.      Define this macro to be the number of bits in an addressable
  452.      storage unit (byte); normally 8.
  453.  
  454. `BITS_PER_WORD'
  455.      Number of bits in a word; normally 32.
  456.  
  457. `MAX_BITS_PER_WORD'
  458.      Maximum number of bits in a word.  If this is undefined, the
  459.      default is `BITS_PER_WORD'.  Otherwise, it is the constant value
  460.      that is the largest value that `BITS_PER_WORD' can have at
  461.      run-time.
  462.  
  463. `UNITS_PER_WORD'
  464.      Number of storage units in a word; normally 4.
  465.  
  466. `POINTER_SIZE'
  467.      Width of a pointer, in bits.
  468.  
  469. `PROMOTE_MODE (M, UNSIGNEDP, TYPE)'
  470.      A macro to update M and UNSIGNEDP when an object whose type is
  471.      TYPE and which has the specified mode and signedness is to be
  472.      stored in a register.  This macro is only called when TYPE is a
  473.      scalar type.
  474.  
  475.      On most RISC machines, which only have operations that operate on
  476.      a full register, define this macro to set M to `word_mode' if M is
  477.      an integer mode narrower than `BITS_PER_WORD'.  In most cases,
  478.      only integer modes should be widened because wider-precision
  479.      floating-point operations are usually more expensive than their
  480.      narrower counterparts.
  481.  
  482.      For most machines, the macro definition does not change UNSIGNEDP.
  483.      However, some machines, have instructions that preferentially
  484.      handle either signed or unsigned quantities of certain modes.  For
  485.      example, on the DEC Alpha, 32-bit loads from memory and 32-bit add
  486.      instructions sign-extend the result to 64 bits.  On such machines,
  487.      set UNSIGNEDP according to which kind of extension is more
  488.      efficient.
  489.  
  490.      Do not define this macro if it would never modify M.
  491.  
  492. `PROMOTE_FUNCTION_ARGS'
  493.      Define this macro if the promotion described by `PROMOTE_MODE'
  494.      should also be done for outgoing function arguments.
  495.  
  496. `PROMOTE_FUNCTION_RETURN'
  497.      Define this macro if the promotion described by `PROMOTE_MODE'
  498.      should also be done for the return value of functions.
  499.  
  500.      If this macro is defined, `FUNCTION_VALUE' must perform the same
  501.      promotions done by `PROMOTE_MODE'.
  502.  
  503. `PARM_BOUNDARY'
  504.      Normal alignment required for function parameters on the stack, in
  505.      bits.  All stack parameters receive at least this much alignment
  506.      regardless of data type.  On most machines, this is the same as the
  507.      size of an integer.
  508.  
  509. `STACK_BOUNDARY'
  510.      Define this macro if you wish to preserve a certain alignment for
  511.      the stack pointer.  The definition is a C expression for the
  512.      desired alignment (measured in bits).
  513.  
  514.      If `PUSH_ROUNDING' is not defined, the stack will always be aligned
  515.      to the specified boundary.  If `PUSH_ROUNDING' is defined and
  516.      specifies a less strict alignment than `STACK_BOUNDARY', the stack
  517.      may be momentarily unaligned while pushing arguments.
  518.  
  519. `FUNCTION_BOUNDARY'
  520.      Alignment required for a function entry point, in bits.
  521.  
  522. `BIGGEST_ALIGNMENT'
  523.      Biggest alignment that any data type can require on this machine,
  524.      in bits.
  525.  
  526. `BIGGEST_FIELD_ALIGNMENT'
  527.      Biggest alignment that any structure field can require on this
  528.      machine, in bits.  If defined, this overrides `BIGGEST_ALIGNMENT'
  529.      for structure fields only.
  530.  
  531. `MAX_OFILE_ALIGNMENT'
  532.      Biggest alignment supported by the object file format of this
  533.      machine.  Use this macro to limit the alignment which can be
  534.      specified using the `__attribute__ ((aligned (N)))' construct.  If
  535.      not defined, the default value is `BIGGEST_ALIGNMENT'.
  536.  
  537. `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)'
  538.      If defined, a C expression to compute the alignment for a static
  539.      variable.  TYPE is the data type, and BASIC-ALIGN is the alignment
  540.      that the object would ordinarily have.  The value of this macro is
  541.      used instead of that alignment to align the object.
  542.  
  543.      If this macro is not defined, then BASIC-ALIGN is used.
  544.  
  545.      One use of this macro is to increase alignment of medium-size data
  546.      to make it all fit in fewer cache lines.  Another is to cause
  547.      character arrays to be word-aligned so that `strcpy' calls that
  548.      copy constants to character arrays can be done inline.
  549.  
  550. `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)'
  551.      If defined, a C expression to compute the alignment given to a
  552.      constant that is being placed in memory.  CONSTANT is the constant
  553.      and BASIC-ALIGN is the alignment that the object would ordinarily
  554.      have.  The value of this macro is used instead of that alignment to
  555.      align the object.
  556.  
  557.      If this macro is not defined, then BASIC-ALIGN is used.
  558.  
  559.      The typical use of this macro is to increase alignment for string
  560.      constants to be word aligned so that `strcpy' calls that copy
  561.      constants can be done inline.
  562.  
  563. `EMPTY_FIELD_BOUNDARY'
  564.      Alignment in bits to be given to a structure bit field that
  565.      follows an empty field such as `int : 0;'.
  566.  
  567.      Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment
  568.      that results from an empty field.
  569.  
  570. `STRUCTURE_SIZE_BOUNDARY'
  571.      Number of bits which any structure or union's size must be a
  572.      multiple of.  Each structure or union's size is rounded up to a
  573.      multiple of this.
  574.  
  575.      If you do not define this macro, the default is the same as
  576.      `BITS_PER_UNIT'.
  577.  
  578. `STRICT_ALIGNMENT'
  579.      Define this macro to be the value 1 if instructions will fail to
  580.      work if given data not on the nominal alignment.  If instructions
  581.      will merely go slower in that case, define this macro as 0.
  582.  
  583. `PCC_BITFIELD_TYPE_MATTERS'
  584.      Define this if you wish to imitate the way many other C compilers
  585.      handle alignment of bitfields and the structures that contain them.
  586.  
  587.      The behavior is that the type written for a bitfield (`int',
  588.      `short', or other integer type) imposes an alignment for the
  589.      entire structure, as if the structure really did contain an
  590.      ordinary field of that type.  In addition, the bitfield is placed
  591.      within the structure so that it would fit within such a field, not
  592.      crossing a boundary for it.
  593.  
  594.      Thus, on most machines, a bitfield whose type is written as `int'
  595.      would not cross a four-byte boundary, and would force four-byte
  596.      alignment for the whole structure.  (The alignment used may not be
  597.      four bytes; it is controlled by the other alignment parameters.)
  598.  
  599.      If the macro is defined, its definition should be a C expression;
  600.      a nonzero value for the expression enables this behavior.
  601.  
  602.      Note that if this macro is not defined, or its value is zero, some
  603.      bitfields may cross more than one alignment boundary.  The
  604.      compiler can support such references if there are `insv', `extv',
  605.      and `extzv' insns that can directly reference memory.
  606.  
  607.      The other known way of making bitfields work is to define
  608.      `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'.  Then
  609.      every structure can be accessed with fullwords.
  610.  
  611.      Unless the machine has bitfield instructions or you define
  612.      `STRUCTURE_SIZE_BOUNDARY' that way, you must define
  613.      `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value.
  614.  
  615.      If your aim is to make GNU CC use the same conventions for laying
  616.      out bitfields as are used by another compiler, here is how to
  617.      investigate what the other compiler does.  Compile and run this
  618.      program:
  619.  
  620.           struct foo1
  621.           {
  622.             char x;
  623.             char :0;
  624.             char y;
  625.           };
  626.           
  627.           struct foo2
  628.           {
  629.             char x;
  630.             int :0;
  631.             char y;
  632.           };
  633.           
  634.           main ()
  635.           {
  636.             printf ("Size of foo1 is %d\n",
  637.                     sizeof (struct foo1));
  638.             printf ("Size of foo2 is %d\n",
  639.                     sizeof (struct foo2));
  640.             exit (0);
  641.           }
  642.  
  643.      If this prints 2 and 5, then the compiler's behavior is what you
  644.      would get from `PCC_BITFIELD_TYPE_MATTERS'.
  645.  
  646. `BITFIELD_NBYTES_LIMITED'
  647.      Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to
  648.      aligning a bitfield within the structure.
  649.  
  650. `ROUND_TYPE_SIZE (STRUCT, SIZE, ALIGN)'
  651.      Define this macro as an expression for the overall size of a
  652.      structure (given by STRUCT as a tree node) when the size computed
  653.      from the fields is SIZE and the alignment is ALIGN.
  654.  
  655.      The default is to round SIZE up to a multiple of ALIGN.
  656.  
  657. `ROUND_TYPE_ALIGN (STRUCT, COMPUTED, SPECIFIED)'
  658.      Define this macro as an expression for the alignment of a structure
  659.      (given by STRUCT as a tree node) if the alignment computed in the
  660.      usual way is COMPUTED and the alignment explicitly specified was
  661.      SPECIFIED.
  662.  
  663.      The default is to use SPECIFIED if it is larger; otherwise, use
  664.      the smaller of COMPUTED and `BIGGEST_ALIGNMENT'
  665.  
  666. `MAX_FIXED_MODE_SIZE'
  667.      An integer expression for the size in bits of the largest integer
  668.      machine mode that should actually be used.  All integer machine
  669.      modes of this size or smaller can be used for structures and
  670.      unions with the appropriate sizes.  If this macro is undefined,
  671.      `GET_MODE_BITSIZE (DImode)' is assumed.
  672.  
  673. `CHECK_FLOAT_VALUE (MODE, VALUE)'
  674.      A C statement to validate the value VALUE (of type `double') for
  675.      mode MODE.  This means that you check whether VALUE fits within
  676.      the possible range of values for mode MODE on this target machine.
  677.      The mode MODE is always `SFmode' or `DFmode'.
  678.  
  679.      If VALUE is not valid, you should call `error' to print an error
  680.      message and then assign some valid value to VALUE.  Allowing an
  681.      invalid value to go through the compiler can produce incorrect
  682.      assembler code which may even cause Unix assemblers to crash.
  683.  
  684.      This macro need not be defined if there is no work for it to do.
  685.  
  686. `TARGET_FLOAT_FORMAT'
  687.      A code distinguishing the floating point format of the target
  688.      machine.  There are three defined values:
  689.  
  690.     `IEEE_FLOAT_FORMAT'
  691.           This code indicates IEEE floating point.  It is the default;
  692.           there is no need to define this macro when the format is IEEE.
  693.  
  694.     `VAX_FLOAT_FORMAT'
  695.           This code indicates the peculiar format used on the Vax.
  696.  
  697.     `UNKNOWN_FLOAT_FORMAT'
  698.           This code indicates any other format.
  699.  
  700.      The value of this macro is compared with `HOST_FLOAT_FORMAT'
  701.      (*note Config::.) to determine whether the target machine has the
  702.      same format as the host machine.  If any other formats are
  703.      actually in use on supported machines, new codes should be defined
  704.      for them.
  705.  
  707. File: gcc.info,  Node: Type Layout,  Next: Registers,  Prev: Storage Layout,  Up: Target Macros
  708.  
  709. Layout of Source Language Data Types
  710. ====================================
  711.  
  712.    These macros define the sizes and other characteristics of the
  713. standard basic data types used in programs being compiled.  Unlike the
  714. macros in the previous section, these apply to specific features of C
  715. and related languages, rather than to fundamental aspects of storage
  716. layout.
  717.  
  718. `INT_TYPE_SIZE'
  719.      A C expression for the size in bits of the type `int' on the
  720.      target machine.  If you don't define this, the default is one word.
  721.  
  722. `SHORT_TYPE_SIZE'
  723.      A C expression for the size in bits of the type `short' on the
  724.      target machine.  If you don't define this, the default is half a
  725.      word.  (If this would be less than one storage unit, it is rounded
  726.      up to one unit.)
  727.  
  728. `LONG_TYPE_SIZE'
  729.      A C expression for the size in bits of the type `long' on the
  730.      target machine.  If you don't define this, the default is one word.
  731.  
  732. `LONG_LONG_TYPE_SIZE'
  733.      A C expression for the size in bits of the type `long long' on the
  734.      target machine.  If you don't define this, the default is two
  735.      words.
  736.  
  737. `CHAR_TYPE_SIZE'
  738.      A C expression for the size in bits of the type `char' on the
  739.      target machine.  If you don't define this, the default is one
  740.      quarter of a word.  (If this would be less than one storage unit,
  741.      it is rounded up to one unit.)
  742.  
  743. `FLOAT_TYPE_SIZE'
  744.      A C expression for the size in bits of the type `float' on the
  745.      target machine.  If you don't define this, the default is one word.
  746.  
  747. `DOUBLE_TYPE_SIZE'
  748.      A C expression for the size in bits of the type `double' on the
  749.      target machine.  If you don't define this, the default is two
  750.      words.
  751.  
  752. `LONG_DOUBLE_TYPE_SIZE'
  753.      A C expression for the size in bits of the type `long double' on
  754.      the target machine.  If you don't define this, the default is two
  755.      words.
  756.  
  757. `DEFAULT_SIGNED_CHAR'
  758.      An expression whose value is 1 or 0, according to whether the type
  759.      `char' should be signed or unsigned by default.  The user can
  760.      always override this default with the options `-fsigned-char' and
  761.      `-funsigned-char'.
  762.  
  763. `DEFAULT_SHORT_ENUMS'
  764.      A C expression to determine whether to give an `enum' type only as
  765.      many bytes as it takes to represent the range of possible values
  766.      of that type.  A nonzero value means to do that; a zero value
  767.      means all `enum' types should be allocated like `int'.
  768.  
  769.      If you don't define the macro, the default is 0.
  770.  
  771. `SIZE_TYPE'
  772.      A C expression for a string describing the name of the data type
  773.      to use for size values.  The typedef name `size_t' is defined
  774.      using the contents of the string.
  775.  
  776.      The string can contain more than one keyword.  If so, separate
  777.      them with spaces, and write first any length keyword, then
  778.      `unsigned' if appropriate, and finally `int'.  The string must
  779.      exactly match one of the data type names defined in the function
  780.      `init_decl_processing' in the file `c-decl.c'.  You may not omit
  781.      `int' or change the order--that would cause the compiler to crash
  782.      on startup.
  783.  
  784.      If you don't define this macro, the default is `"long unsigned
  785.      int"'.
  786.  
  787. `PTRDIFF_TYPE'
  788.      A C expression for a string describing the name of the data type
  789.      to use for the result of subtracting two pointers.  The typedef
  790.      name `ptrdiff_t' is defined using the contents of the string.  See
  791.      `SIZE_TYPE' above for more information.
  792.  
  793.      If you don't define this macro, the default is `"long int"'.
  794.  
  795. `WCHAR_TYPE'
  796.      A C expression for a string describing the name of the data type
  797.      to use for wide characters.  The typedef name `wchar_t' is defined
  798.      using the contents of the string.  See `SIZE_TYPE' above for more
  799.      information.
  800.  
  801.      If you don't define this macro, the default is `"int"'.
  802.  
  803. `WCHAR_TYPE_SIZE'
  804.      A C expression for the size in bits of the data type for wide
  805.      characters.  This is used in `cpp', which cannot make use of
  806.      `WCHAR_TYPE'.
  807.  
  808. `OBJC_INT_SELECTORS'
  809.      Define this macro if the type of Objective C selectors should be
  810.      `int'.
  811.  
  812.      If this macro is not defined, then selectors should have the type
  813.      `struct objc_selector *'.
  814.  
  815. `OBJC_SELECTORS_WITHOUT_LABELS'
  816.      Define this macro if the compiler can group all the selectors
  817.      together into a vector and use just one label at the beginning of
  818.      the vector.  Otherwise, the compiler must give each selector its
  819.      own assembler label.
  820.  
  821.      On certain machines, it is important to have a separate label for
  822.      each selector because this enables the linker to eliminate
  823.      duplicate selectors.
  824.  
  825. `TARGET_BELL'
  826.      A C constant expression for the integer value for escape sequence
  827.      `\a'.
  828.  
  829. `TARGET_BS'
  830. `TARGET_TAB'
  831. `TARGET_NEWLINE'
  832.      C constant expressions for the integer values for escape sequences
  833.      `\b', `\t' and `\n'.
  834.  
  835. `TARGET_VT'
  836. `TARGET_FF'
  837. `TARGET_CR'
  838.      C constant expressions for the integer values for escape sequences
  839.      `\v', `\f' and `\r'.
  840.  
  842. File: gcc.info,  Node: Registers,  Next: Register Classes,  Prev: Type Layout,  Up: Target Macros
  843.  
  844. Register Usage
  845. ==============
  846.  
  847.    This section explains how to describe what registers the target
  848. machine has, and how (in general) they can be used.
  849.  
  850.    The description of which registers a specific instruction can use is
  851. done with register classes; see *Note Register Classes::.  For
  852. information on using registers to access a stack frame, see *Note Frame
  853. Registers::.  For passing values in registers, see *Note Register
  854. Arguments::.  For returning values in registers, see *Note Scalar
  855. Return::.
  856.  
  857. * Menu:
  858.  
  859. * Register Basics::        Number and kinds of registers.
  860. * Allocation Order::        Order in which registers are allocated.
  861. * Values in Registers::        What kinds of values each reg can hold.
  862. * Leaf Functions::        Renumbering registers for leaf functions.
  863. * Stack Registers::        Handling a register stack such as 80387.
  864. * Obsolete Register Macros::    Macros formerly used for the 80387.
  865.  
  867. File: gcc.info,  Node: Register Basics,  Next: Allocation Order,  Up: Registers
  868.  
  869. Basic Characteristics of Registers
  870. ----------------------------------
  871.  
  872. `FIRST_PSEUDO_REGISTER'
  873.      Number of hardware registers known to the compiler.  They receive
  874.      numbers 0 through `FIRST_PSEUDO_REGISTER-1'; thus, the first
  875.      pseudo register's number really is assigned the number
  876.      `FIRST_PSEUDO_REGISTER'.
  877.  
  878. `FIXED_REGISTERS'
  879.      An initializer that says which registers are used for fixed
  880.      purposes all throughout the compiled code and are therefore not
  881.      available for general allocation.  These would include the stack
  882.      pointer, the frame pointer (except on machines where that can be
  883.      used as a general register when no frame pointer is needed), the
  884.      program counter on machines where that is considered one of the
  885.      addressable registers, and any other numbered register with a
  886.      standard use.
  887.  
  888.      This information is expressed as a sequence of numbers, separated
  889.      by commas and surrounded by braces.  The Nth number is 1 if
  890.      register N is fixed, 0 otherwise.
  891.  
  892.      The table initialized from this macro, and the table initialized by
  893.      the following one, may be overridden at run time either
  894.      automatically, by the actions of the macro
  895.      `CONDITIONAL_REGISTER_USAGE', or by the user with the command
  896.      options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'.
  897.  
  898. `CALL_USED_REGISTERS'
  899.      Like `FIXED_REGISTERS' but has 1 for each register that is
  900.      clobbered (in general) by function calls as well as for fixed
  901.      registers.  This macro therefore identifies the registers that are
  902.      not available for general allocation of values that must live
  903.      across function calls.
  904.  
  905.      If a register has 0 in `CALL_USED_REGISTERS', the compiler
  906.      automatically saves it on function entry and restores it on
  907.      function exit, if the register is used within the function.
  908.  
  909. `CONDITIONAL_REGISTER_USAGE'
  910.      Zero or more C statements that may conditionally modify two
  911.      variables `fixed_regs' and `call_used_regs' (both of type `char
  912.      []') after they have been initialized from the two preceding
  913.      macros.
  914.  
  915.      This is necessary in case the fixed or call-clobbered registers
  916.      depend on target flags.
  917.  
  918.      You need not define this macro if it has no work to do.
  919.  
  920.      If the usage of an entire class of registers depends on the target
  921.      flags, you may indicate this to GCC by using this macro to modify
  922.      `fixed_regs' and `call_used_regs' to 1 for each of the registers
  923.      in the classes which should not be used by GCC.  Also define the
  924.      macro `REG_CLASS_FROM_LETTER' to return `NO_REGS' if it is called
  925.      with a letter for a class that shouldn't be used.
  926.  
  927.      (However, if this class is not included in `GENERAL_REGS' and all
  928.      of the insn patterns whose constraints permit this class are
  929.      controlled by target switches, then GCC will automatically avoid
  930.      using these registers when the target switches are opposed to
  931.      them.)
  932.  
  933. `NON_SAVING_SETJMP'
  934.      If this macro is defined and has a nonzero value, it means that
  935.      `setjmp' and related functions fail to save the registers, or that
  936.      `longjmp' fails to restore them.  To compensate, the compiler
  937.      avoids putting variables in registers in functions that use
  938.      `setjmp'.
  939.  
  940. `INCOMING_REGNO (OUT)'
  941.      Define this macro if the target machine has register windows.
  942.      This C expression returns the register number as seen by the
  943.      called function corresponding to the register number OUT as seen
  944.      by the calling function.  Return OUT if register number OUT is not
  945.      an outbound register.
  946.  
  947. `OUTGOING_REGNO (IN)'
  948.      Define this macro if the target machine has register windows.
  949.      This C expression returns the register number as seen by the
  950.      calling function corresponding to the register number IN as seen
  951.      by the called function.  Return IN if register number IN is not an
  952.      inbound register.
  953.  
  955. File: gcc.info,  Node: Allocation Order,  Next: Values in Registers,  Prev: Register Basics,  Up: Registers
  956.  
  957. Order of Allocation of Registers
  958. --------------------------------
  959.  
  960. `REG_ALLOC_ORDER'
  961.      If defined, an initializer for a vector of integers, containing the
  962.      numbers of hard registers in the order in which GNU CC should
  963.      prefer to use them (from most preferred to least).
  964.  
  965.      If this macro is not defined, registers are used lowest numbered
  966.      first (all else being equal).
  967.  
  968.      One use of this macro is on machines where the highest numbered
  969.      registers must always be saved and the save-multiple-registers
  970.      instruction supports only sequences of consecutive registers.  On
  971.      such machines, define `REG_ALLOC_ORDER' to be an initializer that
  972.      lists the highest numbered allocatable register first.
  973.  
  974. `ORDER_REGS_FOR_LOCAL_ALLOC'
  975.      A C statement (sans semicolon) to choose the order in which to
  976.      allocate hard registers for pseudo-registers local to a basic
  977.      block.
  978.  
  979.      Store the desired register order in the array `reg_alloc_order'.
  980.      Element 0 should be the register to allocate first; element 1, the
  981.      next register; and so on.
  982.  
  983.      The macro body should not assume anything about the contents of
  984.      `reg_alloc_order' before execution of the macro.
  985.  
  986.      On most machines, it is not necessary to define this macro.
  987.  
  989. File: gcc.info,  Node: Values in Registers,  Next: Leaf Functions,  Prev: Allocation Order,  Up: Registers
  990.  
  991. How Values Fit in Registers
  992. ---------------------------
  993.  
  994.    This section discusses the macros that describe which kinds of values
  995. (specifically, which machine modes) each register can hold, and how many
  996. consecutive registers are needed for a given mode.
  997.  
  998. `HARD_REGNO_NREGS (REGNO, MODE)'
  999.      A C expression for the number of consecutive hard registers,
  1000.      starting at register number REGNO, required to hold a value of mode
  1001.      MODE.
  1002.  
  1003.      On a machine where all registers are exactly one word, a suitable
  1004.      definition of this macro is
  1005.  
  1006.           #define HARD_REGNO_NREGS(REGNO, MODE)            \
  1007.              ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)  \
  1008.               / UNITS_PER_WORD))
  1009.  
  1010. `HARD_REGNO_MODE_OK (REGNO, MODE)'
  1011.      A C expression that is nonzero if it is permissible to store a
  1012.      value of mode MODE in hard register number REGNO (or in several
  1013.      registers starting with that one).  For a machine where all
  1014.      registers are equivalent, a suitable definition is
  1015.  
  1016.           #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
  1017.  
  1018.      It is not necessary for this macro to check for the numbers of
  1019.      fixed registers, because the allocation mechanism considers them
  1020.      to be always occupied.
  1021.  
  1022.      On some machines, double-precision values must be kept in even/odd
  1023.      register pairs.  The way to implement that is to define this macro
  1024.      to reject odd register numbers for such modes.
  1025.  
  1026.      The minimum requirement for a mode to be OK in a register is that
  1027.      the `movMODE' instruction pattern support moves between the
  1028.      register and any other hard register for which the mode is OK; and
  1029.      that moving a value into the register and back out not alter it.
  1030.  
  1031.      Since the same instruction used to move `SImode' will work for all
  1032.      narrower integer modes, it is not necessary on any machine for
  1033.      `HARD_REGNO_MODE_OK' to distinguish between these modes, provided
  1034.      you define patterns `movhi', etc., to take advantage of this.  This
  1035.      is useful because of the interaction between `HARD_REGNO_MODE_OK'
  1036.      and `MODES_TIEABLE_P'; it is very desirable for all integer modes
  1037.      to be tieable.
  1038.  
  1039.      Many machines have special registers for floating point arithmetic.
  1040.      Often people assume that floating point machine modes are allowed
  1041.      only in floating point registers.  This is not true.  Any
  1042.      registers that can hold integers can safely *hold* a floating
  1043.      point machine mode, whether or not floating arithmetic can be done
  1044.      on it in those registers.  Integer move instructions can be used
  1045.      to move the values.
  1046.  
  1047.      On some machines, though, the converse is true: fixed-point machine
  1048.      modes may not go in floating registers.  This is true if the
  1049.      floating registers normalize any value stored in them, because
  1050.      storing a non-floating value there would garble it.  In this case,
  1051.      `HARD_REGNO_MODE_OK' should reject fixed-point machine modes in
  1052.      floating registers.  But if the floating registers do not
  1053.      automatically normalize, if you can store any bit pattern in one
  1054.      and retrieve it unchanged without a trap, then any machine mode
  1055.      may go in a floating register, so you can define this macro to say
  1056.      so.
  1057.  
  1058.      On some machines, such as the Sparc and the Mips, we get better
  1059.      code by defining `HARD_REGNO_MODE_OK' to forbid integers in
  1060.      floating registers, even though the hardware is capable of
  1061.      handling them.  This is because transferring values between
  1062.      floating registers and general registers is so slow that it is
  1063.      better to keep the integer in memory.
  1064.  
  1065.      The primary significance of special floating registers is rather
  1066.      that they are the registers acceptable in floating point arithmetic
  1067.      instructions.  However, this is of no concern to
  1068.      `HARD_REGNO_MODE_OK'.  You handle it by writing the proper
  1069.      constraints for those instructions.
  1070.  
  1071.      On some machines, the floating registers are especially slow to
  1072.      access, so that it is better to store a value in a stack frame
  1073.      than in such a register if floating point arithmetic is not being
  1074.      done.  As long as the floating registers are not in class
  1075.      `GENERAL_REGS', they will not be used unless some pattern's
  1076.      constraint asks for one.
  1077.  
  1078. `MODES_TIEABLE_P (MODE1, MODE2)'
  1079.      A C expression that is nonzero if it is desirable to choose
  1080.      register allocation so as to avoid move instructions between a
  1081.      value of mode MODE1 and a value of mode MODE2.
  1082.  
  1083.      If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R,
  1084.      MODE2)' are ever different for any R, then `MODES_TIEABLE_P (MODE1,
  1085.      MODE2)' must be zero.
  1086.  
  1088. File: gcc.info,  Node: Leaf Functions,  Next: Stack Registers,  Prev: Values in Registers,  Up: Registers
  1089.  
  1090. Handling Leaf Functions
  1091. -----------------------
  1092.  
  1093.    On some machines, a leaf function (i.e., one which makes no calls)
  1094. can run more efficiently if it does not make its own register window.
  1095. Often this means it is required to receive its arguments in the
  1096. registers where they are passed by the caller, instead of the registers
  1097. where they would normally arrive.
  1098.  
  1099.    The special treatment for leaf functions generally applies only when
  1100. other conditions are met; for example, often they may use only those
  1101. registers for its own variables and temporaries.  We use the term "leaf
  1102. function" to mean a function that is suitable for this special
  1103. handling, so that functions with no calls are not necessarily "leaf
  1104. functions".
  1105.  
  1106.    GNU CC assigns register numbers before it knows whether the function
  1107. is suitable for leaf function treatment.  So it needs to renumber the
  1108. registers in order to output a leaf function.  The following macros
  1109. accomplish this.
  1110.  
  1111. `LEAF_REGISTERS'
  1112.      A C initializer for a vector, indexed by hard register number,
  1113.      which contains 1 for a register that is allowable in a candidate
  1114.      for leaf function treatment.
  1115.  
  1116.      If leaf function treatment involves renumbering the registers,
  1117.      then the registers marked here should be the ones before
  1118.      renumbering--those that GNU CC would ordinarily allocate.  The
  1119.      registers which will actually be used in the assembler code, after
  1120.      renumbering, should not be marked with 1 in this vector.
  1121.  
  1122.      Define this macro only if the target machine offers a way to
  1123.      optimize the treatment of leaf functions.
  1124.  
  1125. `LEAF_REG_REMAP (REGNO)'
  1126.      A C expression whose value is the register number to which REGNO
  1127.      should be renumbered, when a function is treated as a leaf
  1128.      function.
  1129.  
  1130.      If REGNO is a register number which should not appear in a leaf
  1131.      function before renumbering, then the expression should yield -1,
  1132.      which will cause the compiler to abort.
  1133.  
  1134.      Define this macro only if the target machine offers a way to
  1135.      optimize the treatment of leaf functions, and registers need to be
  1136.      renumbered to do this.
  1137.  
  1138. `REG_LEAF_ALLOC_ORDER'
  1139.      If defined, an initializer for a vector of integers, containing the
  1140.      numbers of hard registers in the order in which the GNU CC should
  1141.      prefer to use them (from most preferred to least) in a leaf
  1142.      function.  If this macro is not defined, REG_ALLOC_ORDER is used
  1143.      for both non-leaf and leaf-functions.
  1144.  
  1145.    Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat
  1146. leaf functions specially.  It can test the C variable `leaf_function'
  1147. which is nonzero for leaf functions.  (The variable `leaf_function' is
  1148. defined only if `LEAF_REGISTERS' is defined.)
  1149.  
  1151. File: gcc.info,  Node: Stack Registers,  Next: Obsolete Register Macros,  Prev: Leaf Functions,  Up: Registers
  1152.  
  1153. Registers That Form a Stack
  1154. ---------------------------
  1155.  
  1156.    There are special features to handle computers where some of the
  1157. "registers" form a stack, as in the 80387 coprocessor for the 80386.
  1158. Stack registers are normally written by pushing onto the stack, and are
  1159. numbered relative to the top of the stack.
  1160.  
  1161.    Currently, GNU CC can only handle one group of stack-like registers,
  1162. and they must be consecutively numbered.
  1163.  
  1164. `STACK_REGS'
  1165.      Define this if the machine has any stack-like registers.
  1166.  
  1167. `FIRST_STACK_REG'
  1168.      The number of the first stack-like register.  This one is the top
  1169.      of the stack.
  1170.  
  1171. `LAST_STACK_REG'
  1172.      The number of the last stack-like register.  This one is the
  1173.      bottom of the stack.
  1174.  
  1175. ə